package com.snj.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author yujie
 * @data 2024/8/21 11:15
 */
public class Demo2 {
    public static void main(String[] args) {
        Map<String, List<Integer>> mapList = new HashMap<>();
        List<Integer> oneList = new ArrayList<>();
        List<Integer> twoList = new ArrayList<>();

        // 先 确定一个总的人数
        // 数量
        int oneDept = 25;
        int twoDept = 1;
        // 要求在 5 - 13 之间(并且是奇数)
        // 让 oneDept， twoDept 除 13 得到这两个数 的余数

        // 计算整除结果
        int quotientOneDept = oneDept / 13;
        if (quotientOneDept > 0) {
            for (int i = 0; i < quotientOneDept; i++) {
                oneList.add(13);
            }
        }

        int quotientTwoDept = twoDept / 13;
        if (quotientTwoDept > 0) {
            for (int i = 0; i < quotientTwoDept; i++) {
                twoList.add(13);
            }
        }

        int remainderOneDept = oneDept % 13;
        int remainderTwoDept = twoDept % 13;
        // 判断 余数 是否在  大于等于 5 小于等于13
        // 如果在 判断其是否为奇数
        // 判断余数是否在 5 到 13 之间（包括5和13），并且是奇数
        // 标记剩余人数
        int oneFlag = 0;
        boolean isValidOneDept = isValidRemainder(remainderOneDept);
        if (isValidOneDept) {
            oneList.add(remainderOneDept);
        } else {
            // 余数不是 奇数
            // 判断余数是否大于5
            if (remainderOneDept > 5) {
                int[] ints = findTwoOddNumbers(remainderOneDept);
                if (ints.length > 1) {
                    for (int i = 0; i < ints.length; i++) {
                        oneList.add(ints[i]);
                    }
                } else {
                    for (int i = 0; i < ints.length; i++) {
                        oneList.add(ints[i]);
                    }
                    // 这里最后肯定留下的是 1
                    oneFlag = 1;
                }
            } else {
                oneFlag = remainderOneDept;
            }
        }

        // 标记剩余人数
        int twoFlag = 0;
        boolean isValidTwoDept = isValidRemainder(remainderTwoDept);
        if (isValidTwoDept) {
            twoList.add(remainderTwoDept);
        } else {
            if (remainderTwoDept > 5) {
                int[] ints = findTwoOddNumbers(remainderTwoDept);
                if (ints.length > 1) {
                    for (int i = 0; i < ints.length; i++) {
                        twoList.add(ints[i]);
                    }
                } else {
                    for (int i = 0; i < ints.length; i++) {
                        twoList.add(ints[i]);
                    }
                    // 这里最后肯定留下的是 1
                    twoFlag = 1;
                }
            } else {
                twoFlag = remainderTwoDept;
            }
        }

        System.out.println("1剩余人数: " + oneFlag);
        System.out.println("2剩余人数: " + twoFlag);
        mapList.put("施工", oneList);
        mapList.put("服务", twoList);

        // 计算总剩余
        int totalFlag = oneFlag + twoFlag;
        if (totalFlag > 0) {
            // 遍历 mapList
            for (Map.Entry<String, List<Integer>> entry : mapList.entrySet()) {
                // 获取键
                String key = entry.getKey();
                // 获取对应的值（列表）
                List<Integer> list = entry.getValue();
                if (!list.isEmpty()) {
                    int index = 0;
                    for (Integer i : list) {
                        if (i < 13) {
//                            if (i + oneFlag < 13) {
                            if (i + totalFlag < 13 && totalFlag != 0) {
                                boolean validJiShu = false;
                                if (key.equals("施工")) {
                                    // 判断是否是奇数
                                    validJiShu = isValidJiShu(i + totalFlag);
                                } else {
                                    validJiShu = isValidJiShu(i + totalFlag);
                                }

                                if (validJiShu) {
                                    if (key.equals("施工")) {
                                        System.out.println(i + totalFlag);
                                        list.set(index, i + totalFlag);
                                    } else {
                                        list.set(index, i + totalFlag);
                                    }
                                } else {
                                    if (key.equals("施工")) {
                                        list.set(index, i + totalFlag + 1);
                                    } else {
                                        list.set(index, i + totalFlag + 1);
                                    }
                                }
                                totalFlag = 0;
                                break;
                            } else {
                                // 大于 13
                                list.set(index, 13);
                                totalFlag += i + oneFlag - 13;
                            }
                        }
                        index += 1;
                    }
                }
            }
        }

        System.out.println("总剩余: " + totalFlag);
        System.out.println(mapList);
    }

    // 判断余数是否在 5 到 13 之间（包括5和13），并且是奇数
    private static boolean isValidRemainder(int remainder) {
        return remainder >= 5 && remainder <= 13 && remainder % 2 != 0;
    }

    private static boolean isValidJiShu(int remainder) {
        return remainder % 2 != 0;
    }

    // 查找两个奇数的和等于 input 的值，或返回最接近13的奇数
    private static int[] findTwoOddNumbers(int input) {
        // 确保输入在5到13之间
        if (input < 5 || input > 13) {
            throw new IllegalArgumentException("输入值必须在5到13之间");
        }

        // 奇数数组
        int[] oddNumbers = {5, 7, 9, 11, 13};

        // 寻找两个奇数
        for (int i = 0; i < oddNumbers.length; i++) {
            for (int j = i; j < oddNumbers.length; j++) {
                if (oddNumbers[i] + oddNumbers[j] == input) {
                    return new int[]{oddNumbers[i], oddNumbers[j]};
                }
            }
        }

        // 如果没有找到两个奇数，则返回最接近13的奇数
        return new int[]{(input - 1)};
    }
}
